﻿//#define _CRT_SECURE_NO_WARNINGS
//#include<iostream>
//#include<cstring>
//#include<assert.h>
//#include<vector>
//using namespace std;
//////namespace czy
//////{
//////	template<class T>
//////	struct list_node
//////	{
//////		T _data;
//////		list_node<T>* _next;
//////		list_node<T>* _prev;
//////
//////		/*list_node(const T& data = T())
//////			:_data(data)
//////			,_next(nullptr)
//////			,_prev(nullptr)
//////		{}
//////
//////		list_node(T&& data)
//////			:_data(forward<T>(data))
//////			, _next(nullptr)
//////			, _prev(nullptr)
//////		{}*/
//////
//////		list_node() = default;
//////
//////
//////		template <class ...Args>
//////		list_node(Args&&...args):_data(std::forward<Args>(args)...),_next(nullptr),_prev(nullptr)
//////		{
//////		}
//////
////		/*template<class X>
////		list_node(X&& data)
////			:_data(forward<X>(data))
////			, _next(nullptr)
////			, _prev(nullptr)
////		{}*/
//////	};
//////
//////	template<class T, class Ref, class Ptr>
//////	struct list_iterator
//////	{
//////		typedef list_node<T> Node;
//////		typedef list_iterator<T, Ref, Ptr> Self;
//////		Node* _node;
//////
//////		list_iterator(Node* node)
//////			:_node(node)
//////		{}
//////
//////		Ref operator*()
//////		{
//////			return _node->_data;
//////		}
//////
//////		Ptr operator->()
//////		{
//////			return &_node->_data;
//////		}
//////
//////		Self& operator++()
//////		{
//////			_node = _node->_next;
//////			return *this;
//////		}
//////
//////		Self& operator--()
//////		{
//////			_node = _node->_prev;
//////			return *this;
//////		}
//////
//////		Self operator++(int)
//////		{
//////			Self tmp(*this);
//////			_node = _node->_next;
//////
//////			return tmp;
//////		}
//////
//////		Self& operator--(int)
//////		{
//////			Self tmp(*this);
//////			_node = _node->_prev;
//////
//////			return tmp;
//////		}
//////
//////		bool operator!=(const Self& s) const
//////		{
//////			return _node != s._node;
//////		}
//////
//////		bool operator==(const Self& s) const
//////		{
//////			return _node == s._node;
//////		}
//////	};
//////
//////
//////	
//////	template<class T>
//////	class list
//////	{
//////		typedef list_node<T> Node;
//////	public:
//////		/*typedef list_iterator<T> iterator;
//////		typedef list_const_iterator<T> const_iterator;*/
//////
//////		typedef list_iterator<T, T&, T*> iterator;
//////		typedef list_iterator<T, const T&, const T*> const_iterator;
//////
//////		
//////
//////		
//////		iterator begin()
//////		{
//////			return _head->_next;
//////		}
//////
//////		iterator end()
//////		{
//////			return _head;
//////		}
//////
//////		const_iterator begin() const
//////		{
//////			return _head->_next;
//////		}
//////
//////		const_iterator end() const
//////		{
//////			return _head;
//////		}
//////		template<class ...Args>
//////		void emplace_back(Args&& ...args)
//////		{
//////			insert(end(), std::forward<Args>(args)...);
//////		}
//////		void empty_init()
//////		{
//////			_head = new Node;
//////			_head->_next = _head;
//////			_head->_prev = _head;
//////			_size = 0;
//////		}
//////
//////		list()
//////		{
//////			empty_init();
//////		}
//////
//////		list(initializer_list<T> il)
//////		{
//////			empty_init();
//////			for (auto& e : il)
//////			{
//////				push_back(e);
//////			}
//////		}
//////
//////		 lt2(lt1)
//////		list(const list<T>& lt)
//////		{
//////			empty_init();
//////
//////			for (auto& e : lt)
//////			{
//////				push_back(e);
//////			}
//////		}
//////
//////		 lt1 = lt3
//////		list<T>& operator=(list<T> lt)
//////		{
//////			swap(lt);
//////			return *this;
//////		}
//////
//////		~list()
//////		{
//////			clear();
//////			delete _head;
//////			_head = nullptr;
//////		}
//////
//////		void clear()
//////		{
//////			auto it = begin();
//////			while (it != end())
//////			{
//////				it = erase(it);
//////			}
//////		}
//////
//////		 16:18继续
//////		void swap(list<T>& lt)
//////		{
//////			std::swap(_head, lt._head);
//////			std::swap(_size, lt._size);
//////		}
//////
//////		/*void push_back(const T& x)
//////		{
//////			insert(end(), x);
//////		}
//////
//////		void push_back(T&& x)
//////		{
//////			insert(end(), forward<T>(x));
//////		}*/
//////
//////		 万能引用
//////		template<class X>
//////		void push_back(X&& x)//这里不是
//////		{
//////			insert(end(), forward<X>(x));
//////		}
//////
//////		void push_front(const T& x)
//////		{
//////			insert(begin(), x);
//////		}
//////
//////		
//////		template <class ...Args>
//////		iterator insert(iterator pos, Args&&...args)
//////		{
//////			Node* cur = pos._node;
//////			Node* prev = cur->_prev;
//////			Node* newnode = new Node(forward<Args>(args)...);
//////
//////			 prev newnode cur
//////			newnode->_next = cur;
//////			cur->_prev = newnode;
//////			newnode->_prev = prev;
//////			prev->_next = newnode;
//////
//////			++_size;
//////
//////			return newnode;
//////		}
//////		template<class X>
//////		iterator insert(iterator pos, X&& x)
//////		{
//////			Node* cur = pos._node;
//////			Node* prev = cur->_prev;
//////			Node* newnode = new Node(forward<X>(x));
//////
//////			 prev newnode cur
//////			newnode->_next = cur;
//////			cur->_prev = newnode;
//////			newnode->_prev = prev;
//////			prev->_next = newnode;
//////
//////			++_size;
//////
//////			return newnode;
//////		}
//////
//////		void pop_back()
//////		{
//////			erase(--end());
//////		}
//////
//////		void pop_front()
//////		{
//////			erase(begin());
//////		}
//////
//////		iterator erase(iterator pos)
//////		{
//////			assert(pos != end());
//////
//////			Node* prev = pos._node->_prev;
//////			Node* next = pos._node->_next;
//////
//////			prev->_next = next;
//////			next->_prev = prev;
//////			delete pos._node;
//////
//////			--_size;
//////
//////			return next;
//////		}
//////
//////		size_t size() const
//////		{
//////			return _size;
//////		}
//////
//////		bool empty() const
//////		{
//////			return _size == 0;
//////		}
//////	private:
//////		Node* _head;
//////		size_t _size;
//////	};
//////
//////	struct AA
//////	{
//////		int _a1 = 1;
//////		int _a2 = 1;
//////	};
//////
//////}
//////namespace czy
//////{
//////	class string
//////	{
//////	public:
//////		typedef char* iterator;
//////		typedef const char* const_iterator;
//////
//////		iterator begin()
//////		{
//////			return _str;
//////		}
//////
//////		iterator end()
//////		{
//////			return _str + _size;
//////		}
//////
//////		const_iterator begin() const
//////		{
//////			return _str;
//////		}
//////
//////		const_iterator end() const
//////		{
//////			return _str + _size;
//////		}
//////
//////		string(const char* str = "")
//////			:_size(strlen(str))
//////			, _capacity(_size)
//////		{
//////			cout << "string(char* str)-构造" << endl;
//////			_str = new char[_capacity + 1];
//////			strcpy(_str, str);
//////		}
//////
//////		 拷贝构造
//////		string(const string& s)
//////			:_str(nullptr)
//////		{
//////			cout << "string(const string& s) -- 拷贝构造" << endl;
//////			reserve(s._capacity);
//////			for (auto ch : s)
//////			{
//////				push_back(ch);
//////			}
//////		}
//////
//////		void swap(string& ss)
//////		{
//////			::swap(_str, ss._str);
//////			::swap(_size, ss._size);
//////			::swap(_capacity, ss._capacity);
//////		}
//////
//////		 移动构造
//////		string(string&& s)
//////		{
//////			cout << "string(string&& s) -- 移动构造" << endl;
//////			 转移掠夺你的资源
//////			swap(s);
//////		}
//////
//////		string& operator=(const string& s)
//////		{
//////			cout << "string& operator=(const string& s) -- 拷贝赋值" <<
//////				endl;
//////			if (this != &s)
//////			{
//////				_str[0] = '\0';
//////				_size = 0;
//////				reserve(s._capacity);
//////				for (auto ch : s)
//////				{
//////					push_back(ch);
//////				}
//////			}
//////			return *this;
//////		}
//////
//////		 移动赋值
//////		string& operator=(string&& s)
//////		{
//////			cout << "string& operator=(string&& s) -- 移动赋值" << endl;
//////			swap(s);
//////			return *this;
//////		}
//////
//////		~string()
//////		{
//////			cout << "~string() -- 析构" << endl;
//////			delete[] _str;
//////			_str = nullptr;
//////		}
//////
//////		char& operator[](size_t pos)
//////		{
//////			assert(pos < _size);
//////			return _str[pos];
//////		}
//////
//////		void reserve(size_t n)
//////		{
//////			if (n > _capacity)
//////			{
//////				char* tmp = new char[n + 1];
//////				if (_str)
//////				{
//////					strcpy(tmp, _str);
//////					delete[] _str;
//////				}
//////				_str = tmp;
//////				_capacity = n;
//////			}
//////		}
//////
//////		void push_back(char ch)
//////		{
//////			if (_size >= _capacity)
//////			{
//////				size_t newcapacity = _capacity == 0 ? 4 : _capacity *
//////					2;
//////				reserve(newcapacity);
//////			}
//////			_str[_size] = ch;
//////			++_size;
//////			_str[_size] = '\0';
//////		}
//////
//////		string& operator+=(char ch)
//////		{
//////			push_back(ch);
//////			return *this;
//////		}
//////
//////		const char* c_str() const
//////		{
//////			return _str;
//////		}
//////
//////		size_t size() const
//////		{
//////			return _size;
//////		}
//////	private:
//////		char* _str = nullptr;
//////		size_t _size = 0;
//////		size_t _capacity = 0;
//////	};
//////}
//////
//////class Solution {
//////public:
//////	 传值返回需要拷贝
//////	czy::string addStrings(czy::string num1, czy::string num2) {
//////		czy::string str;
//////		int end1 = num1.size() - 1, end2 = num2.size() - 1;
//////		 进位
//////		int next = 0;
//////		while (end1 >= 0 || end2 >= 0)
//////		{
//////			int val1 = end1 >= 0 ? num1[end1--] - '0' : 0;
//////			int val2 = end2 >= 0 ? num2[end2--] - '0' : 0;
//////			int ret = val1 + val2 + next;
//////			next = ret / 10;
//////			ret = ret % 10;
//////			str += ('0' + ret);
//////		}
//////		if (next == 1)
//////			str += '1';
//////		reverse(str.begin(), str.end());
//////		cout << &str << endl;
//////
//////		return str;
//////	}
//////};
//////int main()
//////{
//////	czy::list<czy::string> lt;//会先调用list的默认构造后面调用调用string的默认构造
//////	czy::string s1("11111111111");//会先调用string构造
//////	lt.push_back(s1);//在new node时会去调用node的构造然后去初始化里面的data这里的就是string会去调用string的拷贝构造
//////
//////	czy::string s2("33333333333");
//////	lt.push_back(move(s2));//在new node时会去调用node的构造然后去初始化里面的data这里的就是string会去调用string的移动构造
//////
//////	lt.push_back("22222222222");//这里是先直接推导X是const char *没有先去构造临时对象，后面直接去构造
//////	return 0;
//////}
//////
//////
//////
//////
//////
//////
//////
//////可变参数个数的模版
//////与函数模版的区别就是这个可以随便改变模版参数的个数
//////函数模版只可以改变模版参数的类型
//////template<class ...Args>
//////void printf(Args&& ... args)
//////{
//////	cout << sizeof...(args)<<endl;//求包的个数
//////}
//////void printf()
//////{
//////	cout << sizeof...(args) << endl;//求包的个数
//////}
//////void printf(int&&  args)
//////{
//////	cout << sizeof...(args) << endl;//求包的个数
//////}
//////void printf(double&&a,int&& args)
//////{
//////	cout << sizeof...(args) << endl;//求包的个数
//////}
//////void printf(const char *arr,double && c,int&& args)
//////{
//////	cout << sizeof...(args) << endl;//求包的个数
//////}
//////int main()
//////{
//////	printf();
//////	printf(21);
//////	printf(1.1,2);
//////	printf("daiud",1,1.2);
//////	return 0;
//////}
//////
//////
//////
//////
//////
//////包扩展
//////
//////
//////编译时的递归函数展开不是运行时的
//////void show()
//////{
//////	cout << endl;
//////}
//////template<class t,class ... args>
//////void show(t a, args... ar)
//////{
//////	cout << a << " ";
//////	show(ar...);
//////}
//////template<class ... Args>
//////void print(Args&& ... args)
//////{
//////	show(args...);
//////}
//////
//////int main()
//////{
//////	print(1,"da",123.2);
//////	print(1,"dd",23.2);
//////	return 0;
//////}
//////
//////
//////
//////第二种
//////template <class T>
//////该函数必须须返回或者到的对象，这样才可以得到一个包去传给get函数
//////T solve(T&& t) 
//////{ 
//////	cout << t << " ";
//////	return t;
//////}
//////template <class ...Args>
//////void get(Args&& ...args)
//////{
//////}
//////template<class ...Args>
//////void print(Args...args)
//////{
//////	get(solve(1),solve(12),solve(32),solve("da"));
//////	get(solve(args)...);
//////}
//////int main()
//////{
//////	print(1, 12, 32, "da");
//////	return 0;
//////}
//////int main()
//////{
//////	print(1, string("xxxxx"), 2.2);
//////	return 0;
//////}
//////
//////
//////
//////
//////
//////
//////
//////empalce系列
//////
//////empalce_back与push_back
//////#include<list>
//////#include<string>
//////using namespace std;
//////int main()
//////{
//////	czy::list<czy::string> lt;//这里有一次string的构造构建头结点
//////	 传左值，跟push_back⼀样，⾛拷⻉构造
//////	czy::string s1("111111111111");//在这里有一次string的构造
//////	lt.push_back(s1);
//////	cout << "*********************************" << endl;
//////	 右值，跟push_back⼀样，⾛移动构造
//////	lt.emplace_back(move(s1));
//////	cout << "*********************************" << endl;
//////
//////	return 0;
//////}
//////
//////int main()
//////{
//////	list<string> lt1;
//////	list<string> lt2;
//////	lt1.push_back("dasd");
//////	lt2.emplace_back("dad");
//////	
//////}
//////
//////
//////c++98的{}
//////struct s
//////{
//////	int x;
//////	int y;
//////};
//////int main()
//////{
//////	int arr[] = { 1,23,232,4314321,323 };
//////	 s s1 = { 1,2 };
//////	return 0;
//////}
//////
//////
//////#include<iostream>
//////#include<vector>
//////using namespace std;
//////struct point
//////{
//////	int _x;
//////	int _y;
//////};
//////class date
//////{
//////public:
//////	date(int year = 1, int month = 1, int day = 1)
//////		:_year(year)
//////		, _month(month)
//////		, _day(day)
//////	{
//////		cout << "date(int year, int month, int day)" << endl;
//////	}
//////	date(const date& d)
//////		:_year(d._year)
//////		, _month(d._month)
//////		, _day(d._day)
//////	{
//////		cout << "date(const date& d)" << endl;
//////	}
//////private:
//////	int _year;
//////	int _month;
//////	int _day;
//////};
//////int main()
//////{
//////	 //c++98⽀持的
//////	int a1[] = { 1, 2, 3, 4, 5 };
//////	int a2[5] = { 0 };
//////	point p = { 1, 2 };
//////
//////
//////
//////	 //c++11⽀持的
//////	 //内置类型⽀持
//////	int x1 = { 2 };
//////	//c++11{}可以省略=
//////	int x2{ 2 };
//////
//////
//////
//////
//////
//////	 //⾃定义类型⽀持
//////	 //这⾥本质是⽤{ 2025, 1, 1}构造⼀个date临时对象
//////	 //临时对象再去拷⻉构造d1，编译器优化后合⼆为⼀变成{ 2025, 1, 1}直接构造初始化d1
//////	 //运⾏⼀下，我们可以验证上⾯的理论，发现是没调⽤拷⻉构造的
//////		date d1 = { 2025, 1, 1 };
//////	 //这⾥d2引⽤的是{ 2024, 7, 25 }构造的临时对象
//////	const date& d2 = { 2024, 7, 25 };
//////	 //需要注意的是c++98⽀持单参数时类型转换，也可以不⽤{}
//////	date d3 = { 2025 };
//////	date d4 = 2025;
//////	 //可以省略掉=
//////	point p1{ 1, 2 };
//////	//int x2{ 2 };
//////	date d6{ 2024, 7, 25 };
//////	const date& d7{ 2024, 7, 25 };
//////	 //不⽀持，只有{}初始化，才能省略=
//////	 //date d8 2025;
//////	vector<date> v;
//////	v.push_back(d1);
//////	v.push_back(date(2025, 1, 1));
//////	 //⽐起有名对象和匿名对象传参，这⾥{}更有性价⽐
//////	v.push_back({ 2025, 1, 1 });
//////	return 0;
//////}
////
//////#include<iostream>
//////#include<vector>
//////#include<string>
//////#include<map>
//////using namespace std;
//////int main()
//////{
//////	std::initializer_list<int> mylist;
//////	mylist = { 10, 20, 30 };
//////	cout << sizeof(mylist) << endl;
//////	// 这⾥begin和end返回的值initializer_list对象中存的两个指针
//////	// 这两个指针的值跟i的地址跟接近，说明数组存在栈上
//////	//也就是说在x86下为8字节x64为16字节
//////	int i = 0;
//////	cout << mylist.begin() << endl;
//////	cout << mylist.end() << endl;
//////	cout << &i << endl;
//////	// {}列表中可以有任意多个值，注意的是里面的多个值一定是同一个类型的
//////	// 这两个写法语义上还是有差别的，第⼀个v1是直接构造，
//////	// 第⼆个v2是构造临时对象+临时对象拷⻉v2+优化为直接构造
//////	vector<int> v1({ 1,2,3,4,5 });
//////	vector<int> v2 = { 1,2,3,4,5 };
//////	//下面这一行代码就可以说明因为临死对象具有常性
//////	const vector<int>& v3 = { 1,2,3,4,5 };
//////	// 这⾥是pair对象的{}初始化和map的initializer_list构造结合到⼀起⽤了
//////	map<string, string> dict = { {"sort", "排序"}, {"string", "字符串"} };
//////	// initializer_list版本的赋值⽀持
//////	v1 = { 10,20,30,40,50 };
//////	return 0;
//////}
////
//#include<iostream>
//#include<assert.h>
//#include<string.h>
//#include<algorithm>
//#include<cstring>
//using namespace std;
//namespace czy
//{
//	class string
//	{
//	public:
//		typedef char* iterator;
//		typedef const char* const_iterator;
//		iterator begin()
//		{
//			return _str;
//		}
//		iterator end()
//		{
//			return _str + _size;
//		}
//		const_iterator begin() const
//		{
//			return _str;
//		}
//		const_iterator end() const
//		{
//			return _str + _size;
//		}
//		//默认构造
//		string(const char* str = "")
//			:_size(strlen(str))
//			, _capacity(_size)
//		{
//			cout << "string(char* str)-构造" << endl;
//			_str = new char[_capacity + 1];
//			strcpy(_str, str);
//		}
//		void swap(string& s)
//		{
//			::swap(_str, s._str);
//			::swap(_size, s._size);
//			::swap(_capacity, s._capacity);
//		}
//		//拷贝构造
//		string(const string& s)
//			:_str(nullptr)
//		{
//			cout << "string(const string& s) -- 拷贝构造" << endl;
//			reserve(s._capacity);
//			for (auto ch : s)
//			{
//				push_back(ch);
//			}
//		}
//		// 移动构造
//		string(string&& s)
//		{
//			cout << "string(string&& s) -- 移动构造" << endl;
//			swap(s);
//		}
//		//赋值构造
//		string& operator=(const string& s)
//		{
//			cout << "string& operator=(const string& s) -- 拷贝赋值" <<
//				endl;
//			if (this != &s)
//			{
//				_str[0] = '\0';
//				_size = 0;
//				reserve(s._capacity);
//				for (auto ch : s)
//				{
//					push_back(ch);
//				}
//			}
//			return *this;
//		}
//		// 移动赋值
//		string& operator=(string&& s)
//		{
//			cout << "string& operator=(string&& s) -- 移动赋值" << endl;
//			swap(s);
//			return *this;
//		}
//		~string()
//		{
//			cout << "~string() -- 析构" << endl;
//			delete[] _str;
//			_str = nullptr;
//		}
//		char& operator[](size_t pos)
//		{
//			assert(pos < _size);
//			return _str[pos];
//		}
//		void reserve(size_t n)
//		{
//			if (n > _capacity)
//			{
//				char* tmp = new char[n + 1];
//				if (_str)
//				{
//					strcpy(tmp, _str);
//					delete[] _str;
//				}
//				_str = tmp;
//				_capacity = n;
//			}
//		}
//		void push_back(char ch)
//		{
//			if (_size >= _capacity)
//			{
//				size_t newcapacity = _capacity == 0 ? 4 : _capacity *
//					2;
//				reserve(newcapacity);
//			}
//			_str[_size] = ch;
//			++_size;
//			_str[_size] = '\0';
//		}
//		string& operator+=(char ch)
//		{
//			push_back(ch);
//			return *this;
//		}
//		const char* c_str() const
//		{
//			return _str;
//		}
//		size_t size() const
//		{
//			return _size;
//		}
//private:
//	char* _str = nullptr;
//	size_t _size = 0;
//	size_t _capacity = 0;
//};
//}
//////int main()
//////{
//////	czy::string s1("xxxxx");
//////	// 拷⻉构造
//////	czy::string s2 = s1;
//////	// 构造+移动构造，优化后直接构造
//////	czy::string s3 = czy::string("yyyyy");
//////	// 移动构造
//////	czy::string s4 = move(s1);
//////	cout << "******************************" << endl;
//////	return 0;
//////}
////
////namespace czy
////{
////	string addStrings(string num1, string num2)
////	{
////		string str;
////		int end1 = num1.size() - 1, end2 = num2.size() - 1;
////		int next = 0;
////		while (end1 >= 0 || end2 >= 0)
////		{
////			int val1 = end1 >= 0 ? num1[end1--] - '0' : 0;
////			int val2 = end2 >= 0 ? num2[end2--] - '0' : 0;
////			int ret = val1 + val2 + next;
////			next = ret / 10;
////			ret = ret % 10;
////			str += ('0' + ret);
////		}
////		if (next == 1)
////			str += '1';
////		reverse(str.begin(), str.end());
////		cout << "******************************" << endl;
////		return str;
////	}
////}
////// 场景1
//////int main()
//////{
//////	czy::string ret = czy::addStrings("11111", "2222");
//////	cout << ret.c_str() << endl;
//////	return 0;
//////}
////// 
//////// 场景2
//////int main()
//////{
//////	czy::string ret;
//////	ret = czy::addStrings("11111", "2222");
//////	cout << ret.c_str() << endl;
//////	return 0;
//////}
////// 由于引⽤折叠限定，f1实例化以后总是⼀个左值引⽤
////template<class T>
////void f1(T& x)
////{}
////// 由于引⽤折叠限定，f2实例化后可以是左值引⽤，也可以是右值引⽤
////template<class T>
////void f2(T&& x)
////{}
////#include<iostream>
////using namespace std;
////
////template<class ...Args>
////void Print(Args&&...args)
////{
////	cout << sizeof...(args)<<endl;
////}
////int main()
////{
////	double x = 2.2;
////	Print(); // 包⾥有0个参数
////	Print(1); // 包⾥有1个参数
////	Print(1, string("xxxxx")); // 包⾥有2个参数
////	Print(1.1, string("xxxxx"), x); // 包⾥有3个参数
////	return 0;
////}
////#include<iostream>
////using namespace std;
////void ShowList()
////{
////	cout << endl;
////}
////template<class T,class ...Args>
////void ShowList(T&&t,Args&&...args)
////{
////	cout << t << " ";
////	ShowList(args...);
////}
////#include<string>
////#include<iostream>
////using namespace std;
////template<class ...Args>
////void ShowList(Args...args)
////{
////}
////template <class T>
////T&& test(T&& t)
////{
////	cout << t << endl;
////	return t;
////}
////template <class ...Args>
////void Print(Args... args)
////{
////	ShowList(test(args)...);
////}
////int main()
////{
////	Print();
////	Print(1);
////	Print(1, string("xxxxx"));
////	Print(1, string("xxxxx"), 2.2);
////	return 0;
////}
//
//
//
//
//
////#include<iostream>
////using namespace std;
////int main()
////{
////	auto func1 = [](int x, int y)->int {return x + y; };
////	auto func2 = [] {cout << "hello world"<<endl; };
////	auto func3 = [](int& a, int& b) {int tem = a; a = b; b = tem; };
////	cout << func1(1, 2) << endl;
////	func2();
////	int a = 1, b = 3;
////	func3(a, b);
////	cout << "a:" << a << "b:" << b << endl;
////	return 0;
////}
//
//class Person
//{
//public:
//	Person(const char* name = "", int age = 0)
//		:_name(name)
//		, _age(age)
//	{}
//	Person(const Person& p)
//		:_name(p._name)
//		, _age(p._age)
//	{}
//	Person(Person&& p) = default;
//	//Person(const Person& p) = delete;
//private:
//	string _name;
//	int _age;
//};
////int main()
////{
////	Person s1;
////	Person s2 = s1;
////	Person s3 = std::move(s1);
////	return 0;
////}
//
//int x = 0;
//// 捕捉列表必须为空，因为全局变量不⽤捕捉就可以⽤，没有可被捕捉的变量
//auto func1 = []()
//	{
//		x++;
//	};
//int main()
//{
//	// 只能⽤当前lambda局部域和捕捉的对象和全局对象
//	int a = 0, b = 1, c = 2, d = 3;
//	auto func1 = [a, &b]
//		{
//			// 值捕捉的变量不能修改，引⽤捕捉的变量可以修改
//			//a++;
//			b++;
//			int ret = a + b;
//			return ret;
//		};
//	cout << func1() << endl;
//	// 隐式值捕捉
//	// ⽤了哪些变量就捕捉哪些变量
//	auto func2 = [=]
//		{
//			int ret = a + b + c;
//			return ret;
//		};
//	cout << func2() << endl;
//	// 隐式引⽤捕捉
//	// ⽤了哪些变量就捕捉哪些变量
//	auto func3 = [&]
//		{
//			a++;
//			c++;
//			d++;
//		};
//	func3();
//	cout << a << " " << b << " " << c << " " << d << endl;
//	// 混合捕捉1
//	auto func4 = [&, a, b]
//		{
//			//a++;
//			//b++;
//			c++;
//			d++;
//			return a + b + c + d;
//		};
//	func4();
//	cout << a << " " << b << " " << c << " " << d << endl;
//	// 混合捕捉1
//	auto func5 = [=, &a, &b]
//		{
//			a++;
//			b++;
//			/*c++;
//			d++;*/
//			return a + b + c + d;
//		};
//	func5();
//	cout << a << " " << b << " " << c << " " << d << endl;
//	// 局部的静态和全局变量不能捕捉，也不需要捕捉
//	static int m = 0;
//	auto func6 = []
//		{
//			int ret = x + m;
//			return ret;
//		};
//	// 传值捕捉本质是⼀种拷⻉,并且被const修饰了
//	// mutable相当于去掉const属性，可以修改了
//	// 但是修改了不会影响外⾯被捕捉的值，因为是⼀种拷⻉
//	auto func7 = [=]()mutable
//		{
//			a++;
//			b++;
//			c++;
//			d++;
//			return a + b + c + d;
//		};
//	cout << func7() << endl;
//	cout << a << " " << b << " " << c << " " << d << endl;
//	return 0;
//}
//
//struct Goods
//{
//	string _name; // 名字
//	double _price; // 价格
//	int _evaluate; // 评价
//	// ...
//	Goods(const char* str, double price, int evaluate)
//		:_name(str)
//		, _price(price)
//		, _evaluate(evaluate)
//	{}
//};
//struct ComparePriceLess
//{
//	bool operator()(const Goods& gl, const Goods& gr)
//	{
//		return gl._price < gr._price;
//	}
//};
//struct ComparePriceGreater
//{
//	bool operator()(const Goods& gl, const Goods& gr)
//	{
//			return gl._price > gr._price;
//	}
//};
//int main()
//{
//	vector<Goods> v = { { "苹果", 2.1, 5 }, { "⾹蕉", 3, 4 }, { "橙⼦", 2.2, 3
//	}, { "菠萝", 1.5, 4 } };
//	// 类似这样的场景，我们实现仿函数对象或者函数指针⽀持商品中
//	// 不同项的⽐较，相对还是⽐较⿇烦的，那么这⾥lambda就很好⽤了
//	sort(v.begin(), v.end(), ComparePriceLess());
//	sort(v.begin(), v.end(), ComparePriceGreater());
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
//		return g1._price < g2._price;
//		});
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
//		return g1._price > g2._price;
//		});
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
//		return g1._evaluate < g2._evaluate;
//		});
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
//		return g1._evaluate > g2._evaluate;
//		});
//	return 0;
//}

//#include<iostream>
//using namespace std;
//#include<functional>
//int f(int a, int b)
//{
//	return a + b;
//}
//struct Functor
//{
//public:
//	int operator() (int a, int b)
//	{
//		return a + b;
//	}
//};
//class Plus
//{
//public:
//	Plus(int n = 10)
//		:_n(n)
//	{}
//	static int plusi(int a, int b)
//	{
//		return a + b;
//	}
//	double plusd(double a, double b)
//	{
//		return (a + b) * _n;
//	}
//private:
//		int _n;
//};
//int main()
//{
//	 包装各种可调⽤对象
//	function<int(int, int)> f1 = f;
//	function<int(int, int)> f2 = Functor();
//	function<int(int, int)> f3 = [](int a, int b) {return a + b; };
//	cout << f1(1, 1) << endl;
//	cout << f2(1, 1) << endl;
//	cout << f3(1, 1) << endl;
//	 包装静态成员函数
//	 成员函数要指定类域并且前⾯加&才能获取地址
//	function<int(int, int)> f4 = &Plus::plusi;
//	cout << f4(1, 1) << endl;
//	 包装普通成员函数
//	 普通成员函数还有⼀个隐含的this指针参数，所以绑定时传对象或者对象的指针过去都可以
//	function<double(Plus*, double, double)> f5 = &Plus::plusd;
//	Plus pd;
//	cout << f5(&pd, 1.1, 1.1) << endl;
//	function<double(Plus, double, double)> f6 = &Plus::plusd;
//	cout << f6(pd, 1.1, 1.1) << endl;
//	cout << f6(pd, 1.1, 1.1) << endl;
//	function<double(Plus&&, double, double)> f7 = &Plus::plusd;
//	cout << f7(move(pd), 1.1, 1.1) << endl;
//	cout << f7(Plus(), 1.1, 1.1) << endl;
//	return 0;
//}
//#include<functional>
//#include<iostream>
//using namespace std;
////占位符
//using placeholders::_1;
//using placeholders::_2;
//using placeholders::_3;
//int Sub(int a, int b)
//{
//	return (a - b) * 10;
//}
//int SubX(int a, int b, int c)
//{
//	return (a - b - c) * 10;
//}
//class Plus
//{
//public:
//	static int plusi(int a, int b)
//	{
//		return a + b;
//	}
//	double plusd(double a, double b)
//	{
//		return a + b;
//	}
//};
//int main()
//{
//
//	function<double(double, double)> fun2 = bind(&Plus::plusd, Plus(), _2, _1);
//	cout << fun2(21, 2.3);
//	return 0;
//}